إطلاق العنان للتزامن في بايثون: ThreadPoolExecutor مقابل ProcessPoolExecutor

بايثون، على الرغم من كونها لغة برمجة متعددة الاستخدامات وشائعة، إلا أن لديها قيودًا معينة عندما يتعلق الأمر بالتوازي الحقيقي بسبب قفل المفسر العام (GIL). توفر وحدة concurrent.futures واجهة عالية المستوى لتنفيذ الدوال بشكل غير متزامن، مما يوفر طريقة للالتفاف على بعض هذه القيود وتحسين الأداء لأنواع معينة من المهام. توفر هذه الوحدة فئتين رئيسيتين: ThreadPoolExecutor و ProcessPoolExecutor. سيستكشف هذا الدليل الشامل كليهما، ويسلط الضوء على اختلافات كل منهما ونقاط القوة والضعف، ويوفر أمثلة عملية لمساعدتك في اختيار المنفذ المناسب لاحتياجاتك.

فهم التزامن والتوازي

قبل التعمق في تفاصيل كل منفذ، من الضروري فهم مفاهيم التزامن والتوازي. غالبًا ما تستخدم هذه المصطلحات بالتبادل، ولكن لها معانٍ مميزة:

• التزامن: يتعامل مع إدارة مهام متعددة في نفس الوقت. يتعلق الأمر بهيكلة التعليمات البرمجية الخاصة بك للتعامل مع أشياء متعددة تبدو متزامنة، حتى لو كانت متداخلة بالفعل على نواة معالج واحدة. فكر في الأمر كطاهٍ يدير عدة قدور على موقد واحد – ليست جميعها تغلي في نفس اللحظة *بالضبط*، لكن الطاهي يديرها كلها.
• التوازي: يتضمن بالفعل تنفيذ مهام متعددة في *نفس* الوقت، عادةً عن طريق استخدام نوى معالجة متعددة. هذا يشبه وجود طهاة متعددين، كل منهم يعمل على جزء مختلف من الوجبة في وقت واحد.

يمنع GIL في بايثون إلى حد كبير التوازي الحقيقي للمهام التي تعتمد على وحدة المعالجة المركزية عند استخدام الخيوط. وذلك لأن GIL يسمح لخيط واحد فقط بالتحكم في مفسر بايثون في أي وقت معين. ومع ذلك، بالنسبة للمهام التي تعتمد على الإدخال/الإخراج، حيث يقضي البرنامج معظم وقته في انتظار عمليات خارجية مثل طلبات الشبكة أو قراءة القرص، لا يزال بإمكان الخيوط توفير تحسينات كبيرة في الأداء عن طريق السماح للخيوط الأخرى بالعمل بينما ينتظر خيط واحد.

مقدمة إلى وحدة `concurrent.futures`

تعمل وحدة concurrent.futures على تبسيط عملية تنفيذ المهام بشكل غير متزامن. وتوفر واجهة عالية المستوى للعمل مع الخيوط والعمليات، مما يزيل الكثير من التعقيد المرتبط بإدارتها مباشرة. المفهوم الأساسي هو "المنفذ" (executor)، الذي يدير تنفيذ المهام المقدمة. المنفذان الأساسيان هما:

• ThreadPoolExecutor: يستخدم مجموعة من الخيوط لتنفيذ المهام. مناسب للمهام التي تعتمد على الإدخال/الإخراج.
• ProcessPoolExecutor: يستخدم مجموعة من العمليات لتنفيذ المهام. مناسب للمهام التي تعتمد على وحدة المعالجة المركزية.

ThreadPoolExecutor: الاستفادة من الخيوط للمهام التي تعتمد على الإدخال/الإخراج

يقوم ThreadPoolExecutor بإنشاء مجموعة من خيوط العمل لتنفيذ المهام. وبسبب GIL، فإن الخيوط ليست مثالية للعمليات كثيفة الحسابات التي تستفيد من التوازي الحقيقي. ومع ذلك، تتفوق في سيناريوهات المهام التي تعتمد على الإدخال/الإخراج. دعنا نستكشف كيفية استخدامها:

الاستخدام الأساسي

إليك مثال بسيط لاستخدام ThreadPoolExecutor لتنزيل صفحات ويب متعددة بشكل متزامن:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Submit each URL to the executor
    futures = [executor.submit(download_page, url) for url in urls]

    # Wait for all tasks to complete
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

شرح:

1. نقوم باستيراد الوحدات الضرورية: concurrent.futures، requests، و time.
2. نقوم بتعريف قائمة بعناوين URL لتنزيلها.
3. تقوم الدالة download_page باسترداد محتوى عنوان URL معين. يتم تضمين معالجة الأخطاء باستخدام `try...except` و `response.raise_for_status()` لالتقاط مشكلات الشبكة المحتملة.
4. نقوم بإنشاء ThreadPoolExecutor بحد أقصى 4 خيوط عمل. يتحكم الوسيط max_workers في العدد الأقصى للخيوط التي يمكن استخدامها بشكل متزامن. قد لا يؤدي تعيين قيمة عالية جدًا دائمًا إلى تحسين الأداء، خاصة في المهام التي تعتمد على الإدخال/الإخراج حيث غالبًا ما تكون سعة عرض النطاق الترددي للشبكة هي عنق الزجاجة.
5. نستخدم قائمة فهم لتقديم كل عنوان URL إلى المنفذ باستخدام executor.submit(download_page, url). هذا يعيد كائن Future لكل مهمة.
6. تعيد الدالة concurrent.futures.as_completed(futures) مُكرِّرًا ينتج الكائنات المستقبلية (futures) عند اكتمالها. هذا يتجنب الانتظار حتى تنتهي جميع المهام قبل معالجة النتائج.
7. نقوم بالتكرار عبر الكائنات المستقبلية المكتملة ونسترجع نتيجة كل مهمة باستخدام future.result()، مع جمع إجمالي البايتات التي تم تنزيلها. تضمن معالجة الأخطاء داخل `download_page` أن الإخفاقات الفردية لا تتسبب في تعطل العملية بأكملها.
8. أخيرًا، نقوم بطباعة إجمالي البايتات التي تم تنزيلها والوقت المستغرق.

فوائد ThreadPoolExecutor

• تزامن مبسط: يوفر واجهة نظيفة وسهلة الاستخدام لإدارة الخيوط.
• أداء مهام الإدخال/الإخراج: ممتاز للمهام التي تقضي قدرًا كبيرًا من الوقت في انتظار عمليات الإدخال/الإخراج، مثل طلبات الشبكة، أو قراءات الملفات، أو استعلامات قواعد البيانات.
• تقليل الحمل الزائد: تتميز الخيوط بشكل عام بحمل زائد أقل مقارنة بالعمليات، مما يجعلها أكثر كفاءة للمهام التي تتضمن تبديل السياق المتكرر.

قيود ThreadPoolExecutor

• قيود GIL: يحد GIL من التوازي الحقيقي للمهام التي تعتمد على وحدة المعالجة المركزية. يمكن لخيط واحد فقط تنفيذ تعليمات بايثون البرمجية في وقت واحد، مما يلغي فوائد النوى المتعددة.
• تعقيد التصحيح: قد يكون تصحيح أخطاء التطبيقات متعددة الخيوط أمرًا صعبًا بسبب حالات السباق (race conditions) وغيرها من المشكلات المتعلقة بالتزامن.

ProcessPoolExecutor: إطلاق العنان لتعدد العمليات للمهام التي تعتمد على وحدة المعالجة المركزية

يتغلب ProcessPoolExecutor على قيود GIL عن طريق إنشاء مجموعة من عمليات العمل. لكل عملية مفسر بايثون خاص بها ومساحة ذاكرة خاصة بها، مما يسمح بالتوازي الحقيقي على الأنظمة متعددة النوى. وهذا يجعله مثاليًا للمهام التي تعتمد على وحدة المعالجة المركزية والتي تتضمن حسابات مكثفة.

الاستخدام الأساسي

لنفترض مهمة مكثفة حسابيًا مثل حساب مجموع المربعات لنطاق كبير من الأرقام. إليك كيفية استخدام ProcessPoolExecutor لتوازي هذه المهمة:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Important for avoiding recursive spawning in some environments
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

شرح:

1. نقوم بتعريف دالة sum_of_squares التي تحسب مجموع المربعات لنطاق معين من الأرقام. نقوم بتضمين `os.getpid()` لمعرفة أي عملية تقوم بتنفيذ كل نطاق.
2. نقوم بتعريف حجم النطاق وعدد العمليات المراد استخدامها. يتم إنشاء قائمة ranges لتقسيم نطاق الحساب الكلي إلى أجزاء أصغر، جزء واحد لكل عملية.
3. نقوم بإنشاء ProcessPoolExecutor بالعدد المحدد من عمليات العمل.
4. نقوم بتقديم كل نطاق إلى المنفذ باستخدام executor.submit(sum_of_squares, start, end).
5. نقوم بجمع النتائج من كل كائن مستقبلي باستخدام future.result().
6. نقوم بجمع النتائج من جميع العمليات للحصول على المجموع الكلي النهائي.

ملاحظة هامة: عند استخدام ProcessPoolExecutor، خاصة على نظام التشغيل ويندوز، يجب عليك إحاطة التعليمات البرمجية التي تنشئ المنفذ داخل كتلة if __name__ == "__main__":. يمنع هذا التفرع المتكرر للعمليات، والذي قد يؤدي إلى أخطاء وسلوك غير متوقع. هذا لأن الوحدة يتم إعادة استيرادها في كل عملية فرعية.

فوائد ProcessPoolExecutor

• التوازي الحقيقي: يتغلب على قيود GIL، مما يسمح بالتوازي الحقيقي على الأنظمة متعددة النوى للمهام التي تعتمد على وحدة المعالجة المركزية.
• تحسين الأداء للمهام التي تعتمد على وحدة المعالجة المركزية: يمكن تحقيق مكاسب كبيرة في الأداء للعمليات كثيفة الحسابات.
• المتانة: إذا تعطلت إحدى العمليات، فإن ذلك لا يؤدي بالضرورة إلى تعطيل البرنامج بأكمله، حيث تكون العمليات معزولة عن بعضها البعض.

قيود ProcessPoolExecutor

• حمل زائد أعلى: إنشاء وإدارة العمليات ينطوي على حمل زائد أعلى مقارنة بالخيوط.
• الاتصال بين العمليات: يمكن أن يكون مشاركة البيانات بين العمليات أكثر تعقيدًا وتتطلب آليات الاتصال بين العمليات (IPC)، والتي يمكن أن تضيف حملاً زائدًا.
• استهلاك الذاكرة: لكل عملية مساحة ذاكرة خاصة بها، مما قد يزيد من إجمالي استهلاك الذاكرة للتطبيق. قد يصبح تمرير كميات كبيرة من البيانات بين العمليات عنق زجاجة.

اختيار المنفذ المناسب: ThreadPoolExecutor مقابل ProcessPoolExecutor

يكمن مفتاح الاختيار بين ThreadPoolExecutor و ProcessPoolExecutor في فهم طبيعة مهامك:

• المهام التي تعتمد على الإدخال/الإخراج: إذا كانت مهامك تقضي معظم وقتها في انتظار عمليات الإدخال/الإخراج (مثل طلبات الشبكة، وقراءة الملفات، واستعلامات قواعد البيانات)، فإن ThreadPoolExecutor هو الخيار الأفضل عمومًا. يكون GIL أقل عنق زجاجة في هذه السيناريوهات، كما أن الحمل الزائد المنخفض للخيوط يجعلها أكثر كفاءة.
• المهام التي تعتمد على وحدة المعالجة المركزية: إذا كانت مهامك كثيفة الحسابات وتستفيد من نوى متعددة، فإن ProcessPoolExecutor هو الحل. إنه يتجاوز قيود GIL ويسمح بالتوازي الحقيقي، مما يؤدي إلى تحسينات كبيرة في الأداء.

إليك جدول يلخص الاختلافات الرئيسية:

الميزة	ThreadPoolExecutor	ProcessPoolExecutor
نموذج التزامن	تعدد الخيوط	تعدد العمليات
تأثير GIL	محدود بواسطة GIL	يتجاوز GIL
مناسب لـ	المهام التي تعتمد على الإدخال/الإخراج	المهام التي تعتمد على وحدة المعالجة المركزية
الحمل الزائد	أقل	أعلى
استهلاك الذاكرة	أقل	أعلى
الاتصال بين العمليات	غير مطلوب (الخيوط تشارك الذاكرة)	مطلوب لمشاركة البيانات
المتانة	أقل متانة (قد يؤثر التعطل على العملية بأكملها)	أكثر متانة (العمليات معزولة)

تقنيات واعتبارات متقدمة

تقديم المهام مع الوسيطات

يسمح كلا المنفذين لك بتمرير الوسيطات إلى الدالة التي يتم تنفيذها. يتم ذلك من خلال طريقة submit():

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

معالجة الاستثناءات

لا يتم نشر الاستثناءات التي تحدث داخل الدالة المنفذة تلقائيًا إلى الخيط الرئيسي أو العملية الرئيسية. تحتاج إلى معالجتها بشكل صريح عند استرداد نتيجة Future:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

استخدام `map` للمهام البسيطة

للمهام البسيطة حيث ترغب في تطبيق نفس الدالة على تسلسل من المدخلات، توفر طريقة map() طريقة موجزة لتقديم المهام:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

التحكم في عدد العمال

يتحكم الوسيط max_workers في كل من ThreadPoolExecutor و ProcessPoolExecutor في العدد الأقصى للخيوط أو العمليات التي يمكن استخدامها بشكل متزامن. يعد اختيار القيمة الصحيحة لـ max_workers أمرًا مهمًا للأداء. نقطة البداية الجيدة هي عدد نوى وحدة المعالجة المركزية المتاحة في نظامك. ومع ذلك، بالنسبة للمهام التي تعتمد على الإدخال/الإخراج، قد تستفيد من استخدام عدد أكبر من الخيوط مقارنة بالنوى، حيث يمكن للخيوط التبديل إلى مهام أخرى أثناء انتظار الإدخال/الإخراج. غالبًا ما تكون التجربة والتحليل ضروريين لتحديد القيمة المثلى.

مراقبة التقدم

لا توفر وحدة concurrent.futures آليات مدمجة لمراقبة تقدم المهام مباشرة. ومع ذلك، يمكنك تنفيذ تتبع التقدم الخاص بك باستخدام وظائف الاستدعاء (callbacks) أو المتغيرات المشتركة. يمكن دمج مكتبات مثل `tqdm` لعرض أشرطة التقدم.

أمثلة من العالم الحقيقي

دعنا ننظر في بعض السيناريوهات الواقعية حيث يمكن تطبيق ThreadPoolExecutor و ProcessPoolExecutor بفعالية:

• الاستخلاص من الويب (Web Scraping): تنزيل وتحليل صفحات ويب متعددة بشكل متزامن باستخدام ThreadPoolExecutor. يمكن لكل خيط التعامل مع صفحة ويب مختلفة، مما يحسن السرعة الإجمالية للاستخلاص. كن حذرًا من شروط خدمة موقع الويب وتجنب إغراق خوادمهم.
• معالجة الصور: تطبيق فلاتر أو تحويلات الصور على مجموعة كبيرة من الصور باستخدام ProcessPoolExecutor. يمكن لكل عملية معالجة صورة مختلفة، مما يستفيد من النوى المتعددة للمعالجة الأسرع. فكر في مكتبات مثل OpenCV لمعالجة الصور بكفاءة.
• تحليل البيانات: إجراء حسابات معقدة على مجموعات بيانات كبيرة باستخدام ProcessPoolExecutor. يمكن لكل عملية تحليل مجموعة فرعية من البيانات، مما يقلل من الوقت الإجمالي للتحليل. تعد Pandas و NumPy من المكتبات الشائعة لتحليل البيانات في بايثون.
• التعلم الآلي: تدريب نماذج التعلم الآلي باستخدام ProcessPoolExecutor. يمكن توازي بعض خوارزميات التعلم الآلي بفعالية، مما يسمح بأوقات تدريب أسرع. توفر مكتبات مثل scikit-learn و TensorFlow دعمًا للتوازي.
• ترميز الفيديو: تحويل ملفات الفيديو إلى تنسيقات مختلفة باستخدام ProcessPoolExecutor. يمكن لكل عملية ترميز جزء مختلف من الفيديو، مما يجعل عملية الترميز الإجمالية أسرع.

اعتبارات عالمية

عند تطوير تطبيقات متزامنة لجمهور عالمي، من المهم مراعاة ما يلي:

• المناطق الزمنية: كن على دراية بالمناطق الزمنية عند التعامل مع العمليات الحساسة للوقت. استخدم مكتبات مثل pytz للتعامل مع تحويلات المنطقة الزمنية.
• الإعدادات المحلية: تأكد من أن تطبيقك يتعامل مع الإعدادات المحلية المختلفة بشكل صحيح. استخدم مكتبات مثل locale لتنسيق الأرقام والتواريخ والعملات وفقًا للإعدادات المحلية للمستخدم.
• ترميز الأحرف: استخدم Unicode (UTF-8) كترميز أحرف افتراضي لدعم مجموعة واسعة من اللغات.
• العولمة (i18n) والترجمة (l10n): صمم تطبيقك ليكون قابلاً للعولمة والترجمة بسهولة. استخدم gettext أو مكتبات ترجمة أخرى لتوفير ترجمات للغات مختلفة.
• تأخير الشبكة: ضع في اعتبارك تأخير الشبكة عند التواصل مع الخدمات البعيدة. قم بتطبيق مهل زمنية ومعالجة أخطاء مناسبة لضمان مرونة تطبيقك تجاه مشكلات الشبكة. يمكن أن يؤثر الموقع الجغرافي للخوادم بشكل كبير على التأخير. فكر في استخدام شبكات توصيل المحتوى (CDNs) لتحسين الأداء للمستخدمين في مناطق مختلفة.

الخاتمة

توفر وحدة concurrent.futures طريقة قوية ومريحة لإدخال التزامن والتوازي في تطبيقات بايثون الخاصة بك. من خلال فهم الاختلافات بين ThreadPoolExecutor و ProcessPoolExecutor، ومن خلال النظر بعناية في طبيعة مهامك، يمكنك تحسين أداء التعليمات البرمجية واستجابتها بشكل كبير. تذكر تحليل التعليمات البرمجية الخاصة بك وتجربة تكوينات مختلفة للعثور على الإعدادات المثلى لحالة الاستخدام الخاصة بك. كن على دراية أيضًا بقيود GIL والتعقيدات المحتملة للبرمجة متعددة الخيوط ومتعددة العمليات. من خلال التخطيط والتنفيذ الدقيقين، يمكنك إطلاق العنان للإمكانات الكاملة للتزامن في بايثون وإنشاء تطبيقات قوية وقابلة للتطوير لجمهور عالمي.